package com.wlz.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * 各种和地图有关的公共方法都在这
 *
 * @author ：Administrator
 * @date ：2018/10/8/008 18:16
 */
public class MapUtils {

    /**
     * 地球半径
     */
    private static double EARTH_RADIUS = 6378.137;

    /**
     * @param d
     * @return
     */
    private static double rad(double d) {
        return d * Math.PI / 180.0;
    }

    private static Logger logger = LoggerFactory.getLogger(MapUtils.class);


    /**
     * 将位置转换成经纬度
     */
    public static Map<String, Double> changeToLongitudeAndLatitude(String localName) {
        Map<String, Double> local = new HashMap<>();
        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/geocode/geo?address=" + localName.trim() + "&output=XML&key=aa6c691ea4e568bae6d9388bc006c98d");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            String msg = "";
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg += line + "\n";
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            String[] lonlat = msg.split("<location>")[1].split("</location>")[0].split(",");
            local.put("longitude", Double.valueOf(lonlat[0]));
            local.put("latitude", Double.valueOf(lonlat[1]));
            System.out.println("经度： " + lonlat[0] + "   纬度： " + lonlat[1]);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return local;
    }


    /**
     * 根据经纬度定位到具体地点
     */
    public static String getLocalNameByLongitudeAndLatitude(double longitude, double latitude) {

        logger.info("根据经纬度获取地理位置");
        Map<String, String> local = new HashMap<>();
        String localName = null;

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            String msg = "";
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg += line + "\n";
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            localName = msg.split("<poi>")[1];
            localName = localName.split("</name>")[0];
            localName = localName.split("<name>")[1];

        } catch (IOException e) {
            e.printStackTrace();
        }
        return localName;
    }


    /**
     * 计算所在经纬度和目标地点之间的距离
     *
     * @param localName 目标地点
     * @param longitude 经度
     * @param latitude  纬度
     * @return 返回距离
     */
    public static String getDistance(String localName, double longitude, double latitude) {
        Map<String, Double> lonlat = changeToLongitudeAndLatitude(localName);
        double radLat1 = rad(lonlat.get("latitude"));
        double radLat2 = rad(latitude);
        double a = radLat1 - radLat2;
        double b = rad(lonlat.get("longitude")) - rad(longitude);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
                + Math.cos(radLat1) * Math.cos(radLat2)
                * Math.pow(Math.sin(b / 2), 2)));
        s = s * EARTH_RADIUS;
        s = Math.round(s * 10000d) / 10000d;
//        s的单位是公里（KM）
        return String.valueOf(s);
    }

    /**
     * 计算所在经纬度和目标地点之间的距离
     *
     * @param localMap  目标地点
     * @param longitude 经度
     * @param latitude  纬度
     * @return 返回距离
     */
    public static String getDistanceByLL(Map<String, Double> localMap, double longitude, double latitude) {
        Map<String, Double> lonlat = localMap;
        double radLat1 = rad(lonlat.get("latitude"));
        double radLat2 = rad(latitude);
        double a = radLat1 - radLat2;
        double b = rad(lonlat.get("longitude")) - rad(longitude);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
                + Math.cos(radLat1) * Math.cos(radLat2)
                * Math.pow(Math.sin(b / 2), 2)));
        s = s * EARTH_RADIUS;
        s = Math.round(s * 10000d) / 10000d;
//        s的单位是公里（KM）
        return String.valueOf(s);
    }


    /**
     * 计算所在经纬度和目标地点之间的距离
     *
     * @param localName 目标地点
     * @param radius    有效半径
     * @param longitude 经度
     * @param latitude  纬度
     * @return 返回距离
     */
    public static boolean getDistance(String localName, Double radius, double longitude, double latitude) {
        boolean flag = true;
        Map<String, Double> lonlat = changeToLongitudeAndLatitude(localName);
        double radLat1 = rad(lonlat.get("latitude"));
        double radLat2 = rad(latitude);
        double a = radLat1 - radLat2;
        double b = rad(lonlat.get("longitude")) - rad(longitude);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
                + Math.cos(radLat1) * Math.cos(radLat2)
                * Math.pow(Math.sin(b / 2), 2)));
        s = s * EARTH_RADIUS;
        s = Math.round(s * 10000d) / 10000d;
//        s的单位是公里（KM）

        if (s < radius) {
            flag = true;
        } else {
            flag = false;
        }

        return flag;
    }


    /**
     * 计算所在经纬度和目标地点之间的距离
     *
     * @param radius    有效半径
     * @param longitude 经度
     * @param latitude  纬度
     * @return 返回距离
     */
    public static boolean getDistance(double localLongitude, double localLatitude, Double radius, double longitude, double latitude) {
        boolean flag = true;
        double radLat1 = rad(localLatitude);
        double radLat2 = rad(latitude);
        double a = radLat1 - radLat2;
        double b = rad(localLongitude) - rad(longitude);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
                + Math.cos(radLat1) * Math.cos(radLat2)
                * Math.pow(Math.sin(b / 2), 2)));
        s = s * EARTH_RADIUS;
        s = Math.round(s * 10000d) / 10000d;
//        s的单位是公里（KM）

        if (s < radius) {
            flag = true;
        } else {
            flag = false;
        }

        return flag;
    }

    /**
     * 根据经纬度获取所在地区的城市编码
     *
     * @param longitude
     * @param latitude
     * @return
     */
    public static String getAmapCityCode(Double longitude, Double latitude) {
        String amapCityCode = "";

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            StringBuilder msg = new StringBuilder();
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg.append(line).append("\n");
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            amapCityCode = msg.toString().split("<citycode>")[1];
            amapCityCode = amapCityCode.split("</citycode>")[0];
        } catch (IOException e) {
            e.printStackTrace();
        }

        return amapCityCode;
    }


    /**
     * 根据经纬度获取所在地区的区域编码(推荐使用这个编码）
     *
     * @param longitude
     * @param latitude
     * @return
     */
    public static String getAmapAdCode(Double longitude, Double latitude) {
        String amapCityCode = "";

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            StringBuilder msg = new StringBuilder();
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg.append(line).append("\n");
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            amapCityCode = msg.toString().split("<adcode>")[1];
            amapCityCode = amapCityCode.split("</adcode>")[0];
        } catch (IOException e) {
            e.printStackTrace();
        }

        return amapCityCode;
    }

    /**
     * 根据经纬度定位到具体地点（全名称地址）
     */
    public static String getDetailLocalNameByLongitudeAndLatitude(double longitude, double latitude) {

        logger.info("根据经纬度获取地理位置");
        Map<String, String> local = new HashMap<>();
        String localName = null;

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            String msg = "";
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg += line + "\n";
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            localName = msg.split("<formatted_address>")[1];
            localName = localName.split("</formatted_address>")[0];

        } catch (IOException e) {
            e.printStackTrace();
            localName = "中国";
        }
        return localName;
    }

    /**
     * 获取包含搜索关键字的周边POI(pageSize默认为20，好像超过25会报错，所以这里固定为20）
     *
     * @param
     * @param adCode
     * @return
     */
//    public static List<PoiBackBean> getSearchLocations(String keyWord, Double reqLongitude, Double reqLatitude, Integer pageNum, String adCode) {
//        List<PoiBackBean> mapList = new ArrayList<>();
//
//        try {
//            // 1. 得到访问地址的URL
//            URL url = new URL("https://restapi.amap.com/v3/place/text?keywords=" + keyWord.trim() + "&city=" + adCode + "&output=xml&offset=20&page=" + pageNum + "&key=aa6c691ea4e568bae6d9388bc006c98d&extensions=all");
////            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
//            // 2. 得到网络访问对象java.net.HttpURLConnection
//            HttpURLConnection connection = (HttpURLConnection) url
//                    .openConnection();
//            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
//            // 设置是否向HttpURLConnection输出
//            connection.setDoOutput(false);
//            // 设置是否从httpUrlConnection读入
//            connection.setDoInput(true);
//            // 设置请求方式
//            connection.setRequestMethod("GET");
//            // 设置是否使用缓存
//            connection.setUseCaches(true);
//            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
//            connection.setInstanceFollowRedirects(true);
//            // 设置超时时间
//            connection.setConnectTimeout(3000);
//            // 连接
//            connection.connect();
//            // 4. 得到响应状态码的返回值 responseCode
//            int code = connection.getResponseCode();
//            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
//            String msg = "";
//            // 正常响应
//            if (code == 200) {
//                // 从流中读取响应信息
//                BufferedReader reader = new BufferedReader(
//                        new InputStreamReader(connection.getInputStream()));
//                String line = null;
//
//                // 循环从流中读取
//                while ((line = reader.readLine()) != null) {
//                    msg += line + "\n";
//                }
//                // 关闭流
//                reader.close();
//            }
//            // 6. 断开连接，释放资源
//            connection.disconnect();
//
//            String[] locations = msg.split("<name>");
//
//            for (int i = 1; i < locations.length; i++) {
//                String name = locations[i].split("</name>")[0];
//                String address = locations[i].split("<address>")[1].split("</address>")[0];
//                String longitude = locations[i].split("<location>")[1].split("</location>")[0].split(",")[0];
//                String latitude = locations[i].split("<location>")[1].split("</location>")[0].split(",")[1];
//
//                Map<String, Double> localMap = new HashMap<>();
//                localMap.put("longitude", Double.valueOf(longitude));
//                localMap.put("latitude", Double.valueOf(latitude));
//                String distance = getDistanceByLL(localMap, reqLongitude, reqLatitude);
//
//                PoiBackBean poiBackBean = new PoiBackBean(name, address, longitude, latitude, distance);
//
//                mapList.add(poiBackBean);
//            }
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return mapList;
//    }

    /**
     * 根据经纬度获取城市名称和区域编码
     *
     * @param longitude
     * @param latitude
     * @param mainMapper
     * @return
     */
//    public static AllCarBean getCityNameAndAdCode(double longitude, double latitude, MainMapper mainMapper) {
//        AllCarBean allCarBean = new AllCarBean();
//
//        try {
//            // 1. 得到访问地址的URL
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
////            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
//            // 2. 得到网络访问对象java.net.HttpURLConnection
//            HttpURLConnection connection = (HttpURLConnection) url
//                    .openConnection();
//            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
//            // 设置是否向HttpURLConnection输出
//            connection.setDoOutput(false);
//            // 设置是否从httpUrlConnection读入
//            connection.setDoInput(true);
//            // 设置请求方式
//            connection.setRequestMethod("GET");
//            // 设置是否使用缓存
//            connection.setUseCaches(true);
//            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
//            connection.setInstanceFollowRedirects(true);
//            // 设置超时时间
//            connection.setConnectTimeout(3000);
//            // 连接
//            connection.connect();
//            // 4. 得到响应状态码的返回值 responseCode
//            int code = connection.getResponseCode();
//            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
//            String msg = "";
//            // 正常响应
//            if (code == 200) {
//                // 从流中读取响应信息
//                BufferedReader reader = new BufferedReader(
//                        new InputStreamReader(connection.getInputStream()));
//                String line = null;
//
//                // 循环从流中读取
//                while ((line = reader.readLine()) != null) {
//                    msg += line + "\n";
//                }
//                // 关闭流
//                reader.close();
//            }
//            // 6. 断开连接，释放资源
//            connection.disconnect();
//
//            String cityName = msg.split("<city>")[1].split("</city>")[0];
//            if (StringUtils.isEmpty(cityName)) {
//                cityName = msg.split("<province>")[1].split("</province>")[0];
//            }
//            String cityCode = mainMapper.getAdCodeByCityName(cityName);
//
//            if (cityCode != null && cityName != null) {
//                allCarBean.setName(cityName);
//                allCarBean.setValue(Integer.parseInt(cityCode));
//            }
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return allCarBean;
//    }

    /**
     * 通过经纬度获取更加详细的地址信息
     *
     * @param longitude 经度
     * @param latitude  纬度
     * @return 封装的地址信息
     */
//    public static SimpleAddressBean getSimpleAddressByLongitudeAndLatitude(Double longitude, Double latitude) {
//        SimpleAddressBean sab = new SimpleAddressBean();
//        try {
//            // 1. 得到访问地址的URL
//            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?output=xml&location=" + longitude + "," + latitude + "&key=aa6c691ea4e568bae6d9388bc006c98d&radius=1000&extensions=all ");
////            URL url = new URL("https://restapi.amap.com/v3/geocode/regeo?key=aa6c691ea4e568bae6d9388bc006c98d&location=" + longitude + "," + latitude);
//            // 2. 得到网络访问对象java.net.HttpURLConnection
//            HttpURLConnection connection = (HttpURLConnection) url
//                    .openConnection();
//            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
//            // 设置是否向HttpURLConnection输出
//            connection.setDoOutput(false);
//            // 设置是否从httpUrlConnection读入
//            connection.setDoInput(true);
//            // 设置请求方式
//            connection.setRequestMethod("GET");
//            // 设置是否使用缓存
//            connection.setUseCaches(true);
//            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
//            connection.setInstanceFollowRedirects(true);
//            // 设置超时时间
//            connection.setConnectTimeout(3000);
//            // 连接
//            connection.connect();
//            // 4. 得到响应状态码的返回值 responseCode
//            int code = connection.getResponseCode();
//            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
//            StringBuilder msg = new StringBuilder();
//            // 正常响应
//            if (code == 200) {
//                // 从流中读取响应信息
//                BufferedReader reader = new BufferedReader(
//                        new InputStreamReader(connection.getInputStream()));
//                String line = null;
//
//                // 循环从流中读取
//                while ((line = reader.readLine()) != null) {
//                    msg.append(line).append("\n");
//                }
//                // 关闭流
//                reader.close();
//            }
//            // 6. 断开连接，释放资源
//            connection.disconnect();
//            String address = msg.toString().split("<formatted_address>")[1].split("</formatted_address>")[0];
//            String province = msg.toString().split("<province>")[1].split("</province>")[0];
//            String city = msg.toString().split("<city>")[1].split("</city>")[0];
//            String region = msg.toString().split("<district>")[1].split("</district>")[0];
//
//            sab.setProvince(province);
//            sab.setCity(city);
//            sab.setRegion(region);
//            sab.setAddress(address);
//
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//
//        return sab;
//    }





    /**
     * 根据经ip地址获取城市信息
     *
     * @param ip ip地址
     * @return 城市信息
     */
    public static String getCityNameByIpAddress(String ip) {
        String localName = null;
        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://restapi.amap.com/v3/ip?ip=192.168.1.6&output=xml&key=aa6c691ea4e568bae6d9388bc006c98d");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            String msg = "";
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg += line + "\n";
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            String provinceName = msg.split("<province>")[1].split("</province>")[0];

            String cityName = msg.split("<city>")[1].split("</city>")[0];

            localName = provinceName + cityName;
            logger.info("地理位置为:  " + localName);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return localName;
    }

}
